/**
 * 定义全局函数模板，用于在WebView中注册全局函数
 */
export function getGlobalFunctionsScript(): string {
    return `
    <script>
        // 获取VS Code API
        const vscode = acquireVsCodeApi();
        
        // 定义全局函数：排除依赖
        window.excludeDependency = function(groupId, artifactId, pomPath) {
            console.log('调用排除依赖:', groupId, artifactId, pomPath);
            
            // 发送消息到扩展
            vscode.postMessage({
                command: 'excludeDependency',
                groupId: groupId,
                artifactId: artifactId,
                pomPath: pomPath
            });
            
            // 更新UI状态，显示正在处理
            markDependencyAsProcessing(groupId, artifactId);
        };
        
        // 在UI中标记依赖为"处理中"状态
        function markDependencyAsProcessing(groupId, artifactId) {
            // 查找相关元素并标记处理状态
            const buttons = document.querySelectorAll('button.exclude-btn[data-group-id="' + groupId + '"][data-artifact-id="' + artifactId + '"]');
            buttons.forEach(function(btn) {
                btn.disabled = true;
                btn.textContent = '排除中...';
                btn.classList.add('processing');
            });
            
            // 查找相关依赖行添加处理中标记
            const depRows = document.querySelectorAll('.dep[data-group-id="' + groupId + '"][data-artifact-id="' + artifactId + '"], .dependency-row[data-group-id="' + groupId + '"][data-artifact-id="' + artifactId + '"]');
            depRows.forEach(function(row) {
                row.classList.add('processing-dep');
            });
        }
        
        // 在UI中标记依赖为"已排除"状态
        function markDependencyAsExcluded(groupId, artifactId) {
            // 查找相关元素并标记已排除状态
            const buttons = document.querySelectorAll('button.exclude-btn[data-group-id="' + groupId + '"][data-artifact-id="' + artifactId + '"]');
            buttons.forEach(function(btn) {
                btn.disabled = true;
                btn.textContent = '已排除';
                btn.classList.remove('processing');
                btn.classList.add('excluded');
            });
            
            // 查找相关依赖行添加已排除标记
            const depRows = document.querySelectorAll('.dep[data-group-id="' + groupId + '"][data-artifact-id="' + artifactId + '"], .dependency-row[data-group-id="' + groupId + '"][data-artifact-id="' + artifactId + '"]');
            depRows.forEach(function(row) {
                row.classList.remove('processing-dep');
                row.classList.add('excluded-dep');
                
                // 添加已排除标记
                const nameElement = row.querySelector('.dep-name');
                if (nameElement && !nameElement.querySelector('.excluded-badge')) {
                    const badge = document.createElement('span');
                    badge.className = 'excluded-badge';
                    badge.textContent = '已排除';
                    nameElement.appendChild(badge);
                }
            });
        }
        
        // 定义全局函数：加载子依赖
        window.loadMoreChildDeps = function(parentId, parentPath, depth) {
            console.log('调用加载子依赖:', parentId, parentPath, depth);
            vscode.postMessage({
                command: 'loadDependencyChildren',
                parentId: parentId, 
                parentPath: parentPath,
                depth: depth,
                containerId: 'children-' + parentId
            });
        };

        // 添加处理loadTab消息的函数
        window.loadTab = function(tabId) {
            console.log('从JS调用loadTab函数:', tabId);
            vscode.postMessage({
                command: 'loadTab',
                tab: tabId
            });
        };
        
        // 处理从扩展发送的消息
        window.addEventListener('message', function(event) {
            const message = event.data;
            console.log('收到扩展消息:', message);
            
            switch(message.command) {
                case 'updateTab':
                    // 处理标签内容更新消息
                    if (message.tab && message.content) {
                        console.log('更新标签内容:', message.tab);
                        // 添加更详细的调试信息
                        const tabId = message.tab + '-tab';
                        console.log("查找标签内容元素ID: " + tabId);
                        console.log("当前所有可用标签内容元素:", Array.from(document.querySelectorAll('.tab-content')).map(el => el.id));
                        
                        const tabContentEl = document.getElementById(tabId);
                        if (tabContentEl) {
                            console.log('找到标签内容元素，更新内容');
                            // 内容长度检查
                            if (message.content && message.content.length > 0) {
                                console.log("接收到内容长度: " + message.content.length);
                                tabContentEl.innerHTML = message.content;
                            } else {
                                console.error('接收到的内容为空');
                                // 添加提示信息
                                tabContentEl.innerHTML = '<div class="no-content">未能加载内容，请尝试刷新</div>';
                            }
                        } else {
                            console.error('未找到标签内容元素:', tabId);
                        }
                    } else {
                        console.error('updateTab 消息缺少必要参数:', message);
                    }
                    break;
                    
                case 'ping':
                    // 响应ping消息，帮助确认WebView通信正常
                    console.log('收到ping消息，响应pong');
                    vscode.postMessage({
                        command: 'pong',
                        timestamp: message.timestamp
                    });
                    break;
                
                case 'dependencyExcluded':
                    // 处理排除依赖成功的消息
                    if (message.groupId && message.artifactId) {
                        console.log('依赖已排除:', message.groupId, message.artifactId);
                        markDependencyAsExcluded(message.groupId, message.artifactId);
                    }
                    break;
                    
                case 'exclusionError':
                    // 处理排除失败的消息
                    if (message.groupId && message.artifactId) {
                        console.error('依赖排除失败:', message.groupId, message.artifactId, message.error);
                        const buttons = document.querySelectorAll('button.exclude-btn[data-group-id="' + message.groupId + '"][data-artifact-id="' + message.artifactId + '"]');
                        buttons.forEach(function(btn) {
                            btn.disabled = false;
                            btn.textContent = '排除 (重试)';
                            btn.classList.remove('processing');
                            btn.classList.add('error');
                        });
                    }
                    break;
                    
                case 'updateSearchResults':
                    // 处理搜索结果更新
                    if (message.content) {
                        console.log('更新搜索结果:', message.searchTerm);
                        const activeTab = document.querySelector('.tab.active');
                        if (activeTab) {
                            const tabId = activeTab.getAttribute('data-tab');
                            const tabContentEl = document.getElementById(tabId + '-tab');
                            if (tabContentEl) {
                                tabContentEl.innerHTML = message.content;
                            }
                        }
                    }
                    break;
                    
                case 'updateDependencyChildren':
                    // 处理子依赖更新
                    if (message.parentId && message.containerId && message.content) {
                        console.log('更新子依赖:', message.parentId);
                        const containerEl = document.getElementById(message.containerId);
                        if (containerEl) {
                            containerEl.innerHTML = message.content;
                        } else {
                            console.error('未找到容器元素:', message.containerId);
                        }
                    }
                    break;
                    
                case 'updateDependencies':
                    // 处理加载更多依赖
                    if (message.content) {
                        console.log('更新依赖列表');
                        const tableBody = document.getElementById('dependencies-table-body');
                        if (tableBody) {
                            // 追加新行到表格
                            tableBody.insertAdjacentHTML('beforeend', message.content);
                            
                            // 更新加载更多按钮状态
                            const loadMoreBtn = document.getElementById('load-more');
                            if (loadMoreBtn) {
                                if (message.hasMore) {
                                    // 更新下一批的起始索引
                                    loadMoreBtn.setAttribute('data-start', message.nextStart);
                                } else {
                                    // 没有更多依赖，隐藏按钮
                                    loadMoreBtn.style.display = 'none';
                                }
                            }
                        } else {
                            console.error('未找到依赖表格体元素');
                        }
                    }
                    break;
                    
                case 'error':
                    // 处理错误消息
                    console.error('扩展报告错误:', message.message);
                    // 可以在UI中显示错误消息
                    const errorDiv = document.createElement('div');
                    errorDiv.className = 'notification error';
                    errorDiv.innerHTML = '<span class="notification-text">错误: ' + message.message + '</span>';
                    
                    // 找到容器并插入错误消息
                    const container = document.querySelector('.container');
                    if (container) {
                        container.insertBefore(errorDiv, container.firstChild);
                        
                        // 5秒后自动移除错误消息
                        setTimeout(() => {
                            errorDiv.remove();
                        }, 5000);
                    }
                    break;
            }
        });
        
        // 添加错误处理
        window.addEventListener('error', function(event) {
            vscode.postMessage({
                command: 'error',
                message: event.message,
                stack: event.error ? event.error.stack : '',
                source: event.filename,
                line: event.lineno
            });
        });

        // 确保所有按钮都有正确的事件处理
        function setupAllButtonHandlers() {
            // 排除按钮
            document.querySelectorAll('.exclude-btn').forEach(function(btn) {
                btn.addEventListener('click', function() {
                    const groupId = this.getAttribute('data-group-id');
                    const artifactId = this.getAttribute('data-artifact-id');
                    const pomPath = this.getAttribute('data-pom-path');
                    
                    console.log('排除按钮点击，参数:', groupId, artifactId, pomPath);
                    
                    if (groupId && artifactId && pomPath) {
                        window.excludeDependency(groupId, artifactId, pomPath);
                    } else {
                        console.error('排除按钮缺少必要属性:', { groupId, artifactId, pomPath });
                        vscode.postMessage({
                            command: 'error',
                            message: '排除按钮缺少必要属性',
                            data: { groupId, artifactId, pomPath }
                        });
                    }
                });
            });

            // 加载更多子依赖按钮
            document.querySelectorAll('.load-more-btn').forEach(function(btn) {
                btn.addEventListener('click', function() {
                    const parentId = this.getAttribute('data-parent-id');
                    const parentPath = this.getAttribute('data-parent-path');
                    const depth = parseInt(this.getAttribute('data-depth') || '0');
                    window.loadMoreChildDeps(parentId, parentPath, depth);
                });
            });
        }

        // 在DOM完成加载后设置所有按钮处理程序
        document.addEventListener('DOMContentLoaded', function() {
            console.log('DOM加载完成，设置按钮处理程序');
            setupAllButtonHandlers();
            
            // 页面加载完成通知
            try {
                console.log('DOM加载完成，发送pageLoaded和webviewReady消息');
                vscode.postMessage({
                    command: 'pageLoaded'
                });
                
                // 也发送webviewReady消息，确保能被接收
                setTimeout(() => {
                    vscode.postMessage({
                        command: 'webviewReady'
                    });
                }, 300);
            } catch (err) {
                console.error('发送页面加载消息失败:', err);
            }
        });

        // 导出一个函数，可以在动态添加元素后调用来更新处理程序
        window.updateButtonHandlers = setupAllButtonHandlers;
    </script>
    `;
}
